// ===========================
// Rust 字符操作：大小写转换与判断
// ===========================
//
// 本案例演示 Rust 中字符操作的核心功能，包括：
// 1. 大小写转换和判断
// 2. 字符类型检测和分类
// 3. 数字字符处理
// 4. 字符编码操作
// 5. 字符比较和排序
// 6. 字符转义和格式化
// 7. 实际应用场景
//
// 学习目标：
// - 掌握字符大小写转换的不同方法
// - 理解 Unicode 复杂转换规则
// - 学习字符分类和判断技巧
// - 掌握字符与数字的相互转换
// - 了解字符编码的底层操作
// - 应用字符操作解决实际问题

fn main() {
    println!("=== Rust 字符操作：大小写转换与判断 ===\n");

    // 1. 大小写转换操作
    demonstrate_case_conversion();

    // 2. 字符类型判断
    demonstrate_character_classification();

    // 3. 数字字符处理
    demonstrate_digit_operations();

    // 4. 字符编码操作
    demonstrate_character_encoding();

    // 5. 字符比较和排序
    demonstrate_character_comparison();

    // 6. 字符转义和格式化
    demonstrate_character_escaping();

    // 7. 实际应用场景
    demonstrate_practical_applications();

    println!("\n=== 程序执行完成 ===");
}

/// 1. 大小写转换操作演示
/// 
/// 知识点：
/// - Rust 字符大小写转换支持完整的 Unicode 规范
/// - to_uppercase() 和 to_lowercase() 返回迭代器，因为某些字符转换后可能变成多个字符
/// - to_ascii_uppercase() 和 to_ascii_lowercase() 仅处理 ASCII 字符，返回单个字符
/// - Unicode 大小写转换规则复杂，涉及语言特定规则
fn demonstrate_case_conversion() {
    println!("1. 大小写转换操作");
    println!("   字符大小写转换是文本处理的基础操作\n");

    println!("1.1 基本大小写转换");
    
    // ASCII 字符转换
    let lowercase_a = 'a';
    let uppercase_a = 'A';
    
    // to_uppercase() 返回迭代器，需要收集成字符串
    let upper_from_lower: String = lowercase_a.to_uppercase().collect();
    let lower_from_upper: String = uppercase_a.to_lowercase().collect();
    
    println!("ASCII 字符转换：");
    println!("  '{}' -> 大写: \"{}\"", lowercase_a, upper_from_lower);
    println!("  '{}' -> 小写: \"{}\"", uppercase_a, lower_from_upper);
    
    // ASCII 快速转换（仅对 ASCII 字符有效）
    let ascii_upper = lowercase_a.to_ascii_uppercase();
    let ascii_lower = uppercase_a.to_ascii_lowercase();
    
    println!("ASCII 快速转换：");
    println!("  '{}' -> ASCII 大写: '{}'", lowercase_a, ascii_upper);
    println!("  '{}' -> ASCII 小写: '{}'", uppercase_a, ascii_lower);

    println!("\n1.2 Unicode 字符转换");
    
    // 中文字符（没有大小写概念）
    let chinese_char = '中';
    let chinese_upper: String = chinese_char.to_uppercase().collect();
    let chinese_lower: String = chinese_char.to_lowercase().collect();
    
    println!("中文字符转换：");
    println!("  '{}' -> 大写: \"{}\" (无变化)", chinese_char, chinese_upper);
    println!("  '{}' -> 小写: \"{}\" (无变化)", chinese_char, chinese_lower);
    
    // 希腊字母转换
    let greek_alpha = 'α';  // 小写希腊字母 alpha
    let greek_upper: String = greek_alpha.to_uppercase().collect();
    
    println!("希腊字母转换：");
    println!("  '{}' -> 大写: \"{}\"", greek_alpha, greek_upper);
    
    println!("\n1.3 复杂的 Unicode 转换");
    
    // 德语 ß 字符的特殊转换
    let german_ss = 'ß';
    let german_upper: String = german_ss.to_uppercase().collect();
    
    println!("德语字符转换：");
    println!("  '{}' -> 大写: \"{}\" (一个字符变成两个)", german_ss, german_upper);
    
    // 土耳其语 i 的特殊情况（这里展示标准转换）
    let turkish_i = 'i';
    let turkish_upper: String = turkish_i.to_uppercase().collect();
    
    println!("土耳其语字符转换：");
    println!("  '{}' -> 大写: \"{}\" (标准转换)", turkish_i, turkish_upper);
    println!("  注：在土耳其语环境中，'i' 的大写应该是 'İ'");

    println!("\n1.4 转换结果的长度变化");
    
    let chars_to_convert = ['a', 'ß', 'α', '中'];
    
    println!("字符转换后的长度变化：");
    for ch in chars_to_convert {
        let uppercase: String = ch.to_uppercase().collect();
        let char_count = uppercase.chars().count();
        let byte_count = uppercase.len();
        
        println!("  '{}' -> \"{}\" (字符数: {}, 字节数: {})", 
                ch, uppercase, char_count, byte_count);
    }

    println!();
}

/// 2. 字符类型判断演示
/// 
/// 知识点：
/// - Rust 提供了丰富的字符分类方法，支持完整的 Unicode 标准
/// - is_uppercase() 和 is_lowercase() 判断字符是否有大小写概念
/// - is_alphabetic() 判断是否为字母（包括各国文字）
/// - is_ascii_*() 系列方法仅检查 ASCII 范围内的字符，性能更高
/// - 字符分类基于 Unicode 字符属性数据库
fn demonstrate_character_classification() {
    println!("2. 字符类型判断");
    println!("   字符分类是文本分析和验证的基础\n");

    println!("2.1 大小写判断");
    
    let test_chars = ['A', 'a', 'Z', 'z', '中', 'α', 'Α', '1', '!'];
    
    println!("字符大小写属性：");
    for ch in test_chars {
        let is_upper = ch.is_uppercase();
        let is_lower = ch.is_lowercase();
        let has_case = is_upper || is_lower;
        
        println!("  '{}': 大写={}, 小写={}, 有大小写={}", 
                ch, is_upper, is_lower, has_case);
    }
    
    println!("\n2.2 字符类型分类");
    
    let mixed_chars = ['A', 'a', '中', '1', '①', ' ', '\n', '!', 'α', '😀'];
    
    println!("详细字符分类：");
    for ch in mixed_chars {
        println!("  '{}' ({:?}):", ch, ch.escape_debug().collect::<String>());
        println!("    字母: {}, 数字: {}, 字母数字: {}", 
                ch.is_alphabetic(), ch.is_numeric(), ch.is_alphanumeric());
        println!("    ASCII: {}, 空白: {}, 控制: {}", 
                ch.is_ascii(), ch.is_whitespace(), ch.is_control());
        println!("    ASCII字母: {}, ASCII数字: {}", 
                ch.is_ascii_alphabetic(), ch.is_ascii_digit());
    }
    
    println!("\n2.3 高级字符属性判断");
    
    let special_chars = ['A', 'a', '1', ' ', '\t', '\n', '!', '@', '中', 'α'];
    
    println!("高级字符属性：");
    for ch in special_chars {
        let mut properties = Vec::new();
        
        if ch.is_ascii_uppercase() { properties.push("ASCII大写"); }
        if ch.is_ascii_lowercase() { properties.push("ASCII小写"); }
        if ch.is_ascii_digit() { properties.push("ASCII数字"); }
        if ch.is_ascii_hexdigit() { properties.push("十六进制数字"); }
        if ch.is_ascii_punctuation() { properties.push("ASCII标点"); }
        if ch.is_ascii_graphic() { properties.push("ASCII图形字符"); }
        if ch.is_ascii_whitespace() { properties.push("ASCII空白"); }
        if ch.is_ascii_control() { properties.push("ASCII控制"); }
        
        let props_str = if properties.is_empty() {
            "无特殊属性".to_string()
        } else {
            properties.join(", ")
        };
        
        println!("  '{}': {}", ch, props_str);
    }

    println!();
}

/// 3. 数字字符处理演示
/// 
/// 知识点：
/// - to_digit() 将字符转换为对应的数值，支持 2-36 进制
/// - from_digit() 将数值转换为对应的字符表示
/// - 支持 Unicode 数字字符，不仅仅是 ASCII 0-9
/// - 进制转换在编程中广泛应用于数据解析和格式化
fn demonstrate_digit_operations() {
    println!("3. 数字字符处理");
    println!("   数字字符转换在数据解析中非常重要\n");

    println!("3.1 字符转数字");
    
    // ASCII 数字字符
    let digit_chars = ['0', '1', '9', 'A', 'F', 'a', 'f', 'Z'];
    
    println!("不同进制的字符转数字：");
    for ch in digit_chars {
        // 尝试不同的进制
        let decimal = ch.to_digit(10);
        let hex = ch.to_digit(16);
        let max_radix = ch.to_digit(36);
        
        print!("  '{}': ", ch);
        
        if let Some(val) = decimal {
            print!("十进制={}", val);
        } else {
            print!("十进制=无效");
        }
        
        if let Some(val) = hex {
            print!(", 十六进制={}", val);
        } else {
            print!(", 十六进制=无效");
        }
        
        if let Some(val) = max_radix {
            print!(", 36进制={}", val);
        } else {
            print!(", 36进制=无效");
        }
        
        println!();
    }
    
    println!("\n3.2 数字转字符");
    
    println!("数字转换为不同进制的字符：");
    for num in 0..=15 {
        let decimal_char = std::char::from_digit(num, 10);
        let hex_char = std::char::from_digit(num, 16);
        
        print!("  {}: ", num);
        
        if let Some(ch) = decimal_char {
            print!("十进制='{}'", ch);
        } else {
            print!("十进制=无效");
        }
        
        if let Some(ch) = hex_char {
            print!(", 十六进制='{}'", ch);
        } else {
            print!(", 十六进制=无效");
        }
        
        println!();
    }
    
    println!("\n3.3 Unicode 数字字符");
    
    // Unicode 数字字符（不仅仅是 ASCII）
    let unicode_digits = ['0', '1', '２', '３', '①', '②', '一', '二', '٠', '١'];
    
    println!("Unicode 数字字符识别：");
    for ch in unicode_digits {
        let is_numeric = ch.is_numeric();
        let is_ascii_digit = ch.is_ascii_digit();
        let decimal_value = ch.to_digit(10);
        
        println!("  '{}': 数字={}, ASCII数字={}, 十进制值={:?}", 
                ch, is_numeric, is_ascii_digit, decimal_value);
    }
    
    println!("\n3.4 进制转换应用");
    
    let hex_string = "1A2B";
    println!("解析十六进制字符串 \"{}\":", hex_string);
    
    let mut result = 0u32;
    let mut success = true;
    
    for ch in hex_string.chars() {
        if let Some(digit) = ch.to_digit(16) {
            result = result * 16 + digit;
            println!("  '{}' -> {}, 累计: {}", ch, digit, result);
        } else {
            println!("  '{}' -> 无效的十六进制字符", ch);
            success = false;
            break;
        }
    }
    
    if success {
        println!("  解析结果: {} (十进制), 0x{:X} (十六进制)", result, result);
    }

    println!();
}

/// 4. 字符编码操作演示
/// 
/// 知识点：
/// - char 类型在 Rust 中是 Unicode 标量值，占用 4 字节
/// - encode_utf8() 将字符编码为 UTF-8 字节序列
/// - encode_utf16() 将字符编码为 UTF-16 代码单元序列
/// - len_utf8() 和 len_utf16() 返回编码后的长度
/// - 不同字符在不同编码下的长度可能不同
fn demonstrate_character_encoding() {
    println!("4. 字符编码操作");
    println!("   理解字符在不同编码下的表示形式\n");

    println!("4.1 UTF-8 编码");
    
    let test_chars = ['A', '中', '🚀', '𝓐'];  // ASCII, 中文, 表情, 数学符号
    
    println!("字符的 UTF-8 编码：");
    for ch in test_chars {
        // 创建缓冲区用于编码
        let mut utf8_buf = [0u8; 4];
        let utf8_str = ch.encode_utf8(&mut utf8_buf);
        let utf8_len = ch.len_utf8();
        
        print!("  '{}' (U+{:04X}): ", ch, ch as u32);
        print!("UTF-8长度={}, 字节=[", utf8_len);
        
        for (i, &byte) in utf8_str.as_bytes().iter().enumerate() {
            if i > 0 { print!(", "); }
            print!("0x{:02X}", byte);
        }
        
        println!("]");
    }
    
    println!("\n4.2 UTF-16 编码");
    
    println!("字符的 UTF-16 编码：");
    for ch in test_chars {
        let mut utf16_buf = [0u16; 2];
        let utf16_slice = ch.encode_utf16(&mut utf16_buf);
        let utf16_len = ch.len_utf16();
        
        print!("  '{}' (U+{:04X}): ", ch, ch as u32);
        print!("UTF-16长度={}, 代码单元=[", utf16_len);
        
        for (i, &unit) in utf16_slice.iter().enumerate() {
            if i > 0 { print!(", "); }
            print!("0x{:04X}", unit);
        }
        
        println!("]");
    }
    
    println!("\n4.3 编码长度比较");
    
    println!("不同字符的编码长度比较：");
    println!("  字符 | Unicode  | UTF-8 | UTF-16 | UTF-32 | 描述");
    println!("  -----|----------|-------|--------|--------|--------");
    
    for ch in test_chars {
        let unicode = ch as u32;
        let utf8_len = ch.len_utf8();
        let utf16_len = ch.len_utf16();
        let utf32_len = 4;  // char 类型总是 4 字节
        
        let description = match ch {
            'A' => "ASCII字符",
            '中' => "中文字符",
            '🚀' => "表情符号",
            '𝓐' => "数学符号",
            _ => "其他字符",
        };
        
        println!("  '{}' | U+{:04X}  | {}字节  | {}单元  | {}字节   | {}", 
                ch, unicode, utf8_len, utf16_len, utf32_len, description);
    }
    
    println!("\n4.4 编码和解码操作");
    
    let original_char = '中';
    println!("编码和解码示例（字符: '{}'）:", original_char);
    
    // UTF-8 编码和解码
    let mut utf8_buf = [0u8; 4];
    let utf8_str = original_char.encode_utf8(&mut utf8_buf);
    println!("  UTF-8 编码: {:?}", utf8_str.as_bytes());
    
    // 从 UTF-8 字符串获取第一个字符
    if let Some(decoded_char) = utf8_str.chars().next() {
        println!("  UTF-8 解码: '{}' (成功)", decoded_char);
    }
    
    // 直接从 Unicode 码点创建字符
    let code_point = original_char as u32;
    if let Some(char_from_code) = std::char::from_u32(code_point) {
        println!("  从码点 {} 创建: '{}' (成功)", code_point, char_from_code);
    }

    println!();
}

/// 5. 字符比较和排序演示
/// 
/// 知识点：
/// - 字符比较基于 Unicode 码点值
/// - ASCII 字符的排序符合常规预期
/// - 不同语言的字符排序可能不符合该语言的字典序
/// - 实际应用中可能需要使用专门的本地化排序库
fn demonstrate_character_comparison() {
    println!("5. 字符比较和排序");
    println!("   字符比较基于 Unicode 码点值\n");

    println!("5.1 基本字符比较");
    
    let char_pairs = [
        ('A', 'B'),
        ('a', 'A'),
        ('0', '9'),
        ('中', '国'),
        ('α', 'β'),
    ];
    
    println!("字符比较结果：");
    for (ch1, ch2) in char_pairs {
        let code1 = ch1 as u32;
        let code2 = ch2 as u32;
        
        println!("  '{}' (U+{:04X}) vs '{}' (U+{:04X}): ", ch1, code1, ch2, code2);
        
        if ch1 < ch2 {
            println!("    '{}' < '{}'", ch1, ch2);
        } else if ch1 > ch2 {
            println!("    '{}' > '{}'", ch1, ch2);
        } else {
            println!("    '{}' == '{}'", ch1, ch2);
        }
    }
    
    println!("\n5.2 字符排序");
    
    let mut mixed_chars = ['z', 'A', '中', 'a', '1', 'Z', '国', '9', 'α'];
    println!("排序前: {:?}", mixed_chars);
    
    // 按 Unicode 码点排序
    mixed_chars.sort();
    println!("排序后: {:?}", mixed_chars);
    
    println!("排序后的详细信息：");
    for ch in mixed_chars {
        println!("  '{}' (U+{:04X})", ch, ch as u32);
    }
    
    println!("\n5.3 字符范围检查");
    
    let test_chars = ['A', 'M', 'Z', 'a', 'm', 'z', '0', '5', '9'];
    
    println!("字符范围检查：");
    for ch in test_chars {
        let mut ranges = Vec::new();
        
        if ch >= 'A' && ch <= 'Z' {
            ranges.push("大写字母");
        }
        if ch >= 'a' && ch <= 'z' {
            ranges.push("小写字母");
        }
        if ch >= '0' && ch <= '9' {
            ranges.push("数字字符");
        }
        
        let ranges_str = if ranges.is_empty() {
            "不在常见范围内".to_string()
        } else {
            ranges.join(", ")
        };
        
        println!("  '{}': {}", ch, ranges_str);
    }
    
    println!("\n5.4 自定义比较规则");
    
    let mut chars_for_custom_sort = ['a', 'B', 'c', 'A'];
    println!("自定义排序前: {:?}", chars_for_custom_sort);
    
    // 忽略大小写排序
    chars_for_custom_sort.sort_by(|a, b| {
        a.to_lowercase().collect::<String>().cmp(&b.to_lowercase().collect::<String>())
    });
    println!("忽略大小写排序: {:?}", chars_for_custom_sort);
    
    // 按字符类型排序（数字 < 大写字母 < 小写字母）
    let mut mixed_for_type_sort = ['a', '1', 'B', '9', 'c', 'A'];
    println!("类型排序前: {:?}", mixed_for_type_sort);
    
    mixed_for_type_sort.sort_by(|a, b| {
        let type_a = if a.is_ascii_digit() { 0 } 
                    else if a.is_ascii_uppercase() { 1 }
                    else if a.is_ascii_lowercase() { 2 }
                    else { 3 };
        
        let type_b = if b.is_ascii_digit() { 0 }
                    else if b.is_ascii_uppercase() { 1 }
                    else if b.is_ascii_lowercase() { 2 }
                    else { 3 };
        
        type_a.cmp(&type_b).then(a.cmp(b))
    });
    println!("类型排序后: {:?}", mixed_for_type_sort);

    println!();
}

/// 6. 字符转义和格式化演示
/// 
/// 知识点：
/// - escape_default() 使用 Rust 默认的转义规则
/// - escape_debug() 专用于调试输出，确保字符可读
/// - escape_unicode() 总是使用 Unicode 转义格式
/// - 转义在字符串字面量、调试输出、数据序列化中广泛应用
fn demonstrate_character_escaping() {
    println!("6. 字符转义和格式化");
    println!("   字符转义用于安全显示和数据传输\n");

    println!("6.1 基本字符转义");
    
    let special_chars = ['\n', '\t', '\r', '\\', '\'', '\"', '\0'];
    
    println!("特殊字符的转义表示：");
    for ch in special_chars {
        let default_escape: String = ch.escape_default().collect();
        let debug_escape: String = ch.escape_debug().collect();
        let unicode_escape: String = ch.escape_unicode().collect();
        
        println!("  字符 (U+{:04X}):", ch as u32);
        println!("    默认转义: {}", default_escape);
        println!("    调试转义: {}", debug_escape);
        println!("    Unicode转义: {}", unicode_escape);
        
        // 显示字符的含义
        let meaning = match ch {
            '\n' => "换行符",
            '\t' => "制表符",
            '\r' => "回车符",
            '\\' => "反斜杠",
            '\'' => "单引号",
            '\"' => "双引号",
            '\0' => "空字符",
            _ => "其他",
        };
        println!("    含义: {}", meaning);
        println!();
    }
    
    println!("6.2 可见字符的转义");
    
    let visible_chars = ['A', '中', '🚀', ' ', '!', '@'];
    
    println!("可见字符的不同转义方式：");
    for ch in visible_chars {
        let default_escape: String = ch.escape_default().collect();
        let debug_escape: String = ch.escape_debug().collect();
        let unicode_escape: String = ch.escape_unicode().collect();
        
        println!("  '{}' (U+{:04X}):", ch, ch as u32);
        println!("    默认转义: {}", default_escape);
        println!("    调试转义: {}", debug_escape);
        println!("    Unicode转义: {}", unicode_escape);
        println!();
    }
    
    println!("6.3 转义在字符串中的应用");
    
    // 模拟生成 Rust 字符串字面量
    let chars_to_escape = ['A', '\n', '\\', '\"', '中'];
    
    println!("生成 Rust 字符串字面量：");
    print!("let s = \"");
    for ch in chars_to_escape {
        let escaped: String = ch.escape_default().collect();
        print!("{}", escaped);
    }
    println!("\";");
    
    // 显示实际字符串内容
    let actual_string: String = chars_to_escape.iter().collect();
    println!("字符串实际内容: {:?}", actual_string);
    
    println!("\n6.4 JSON 安全转义");
    
    let json_unsafe_chars = ['\"', '\\', '\n', '\t', '\r', '\u{08}', '\u{0C}'];
    
    println!("JSON 需要转义的字符：");
    for ch in json_unsafe_chars {
        let json_safe = match ch {
            '\"' => "\\\"".to_string(),
            '\\' => "\\\\".to_string(),
            '\n' => "\\n".to_string(),
            '\t' => "\\t".to_string(),
            '\r' => "\\r".to_string(),
            '\u{08}' => "\\b".to_string(),  // backspace
            '\u{0C}' => "\\f".to_string(),  // form feed
            _ => ch.to_string(),
        };
        
        println!("  字符: {:?} -> JSON: \"{}\"", ch, json_safe);
    }

    println!();
}

/// 7. 实际应用场景演示
/// 
/// 这个模块展示字符操作在实际编程中的应用，包括：
/// - 文本标准化和清理
/// - 用户输入验证
/// - 密码强度检查
/// - 简单的词法分析
fn demonstrate_practical_applications() {
    println!("7. 实际应用场景");
    println!("   字符操作在实际开发中的应用示例\n");

    println!("7.1 文本标准化");
    
    let messy_text = "  Hello   World!  \n\t  ";
    println!("原始文本: {:?}", messy_text);
    
    // 移除多余的空白字符
    let normalized: String = messy_text
        .chars()
        .filter(|ch| !ch.is_whitespace() || *ch == ' ')
        .collect::<String>()
        .split_whitespace()
        .collect::<Vec<&str>>()
        .join(" ");
    
    println!("标准化后: {:?}", normalized);
    
    println!("\n7.2 用户名验证");
    
    let usernames = ["user123", "User_Name", "用户名", "user@domain", "123user", ""];
    
    println!("用户名验证结果：");
    for username in usernames {
        let (is_valid, reason) = validate_username(username);
        println!("  \"{}\": {}, 原因: {}", username, if is_valid { "✓ 有效" } else { "✗ 无效" }, reason);
    }
    
    println!("\n7.3 密码强度检查");
    
    let passwords = ["123456", "Password", "password123", "P@ssw0rd!", ""];
    
    println!("密码强度检查结果：");
    for password in passwords {
        let strength = check_password_strength(password);
        println!("  \"{}\": {}", password, strength);
    }
    
    println!("\n7.4 文本清理和格式化");
    
    let dirty_text = "Hello\x00World\t\tGood\r\nBye\x7F";
    println!("原始文本: {:?}", dirty_text);
    
    let cleaned = clean_text(dirty_text);
    println!("清理后: {:?}", cleaned);
    
    println!("\n7.5 简单词法分析");
    
    let code_snippet = "let x = 42; // 注释";
    println!("代码片段: \"{}\"", code_snippet);
    
    let tokens = tokenize_simple(code_snippet);
    println!("词法分析结果:");
    for (i, token) in tokens.iter().enumerate() {
        println!("  Token {}: {:?}", i + 1, token);
    }
    
    println!("\n7.6 国际化文本长度计算");
    
    let texts = ["Hello", "你好", "🌍🚀", "Café"];
    
    println!("不同文本的长度统计：");
    for text in texts {
        let char_count = text.chars().count();
        let byte_count = text.len();
        let grapheme_count = count_graphemes(text);
        
        println!("  \"{}\": 字符数={}, 字节数={}, 字形数={}", 
                text, char_count, byte_count, grapheme_count);
    }

    println!();
}

/// 用户名验证函数
/// 
/// 验证规则：
/// - 长度在 3-20 个字符之间
/// - 只能包含字母、数字和下划线
/// - 不能以数字开头
/// - 不能为空
fn validate_username(username: &str) -> (bool, String) {
    if username.is_empty() {
        return (false, "用户名不能为空".to_string());
    }
    
    if username.chars().count() < 3 {
        return (false, "用户名太短（至少3个字符）".to_string());
    }
    
    if username.chars().count() > 20 {
        return (false, "用户名太长（最多20个字符）".to_string());
    }
    
    // 检查第一个字符
    if let Some(first_char) = username.chars().next() {
        if first_char.is_ascii_digit() {
            return (false, "用户名不能以数字开头".to_string());
        }
    }
    
    // 检查所有字符
    for ch in username.chars() {
        if !ch.is_alphanumeric() && ch != '_' {
            return (false, format!("包含无效字符: '{}'", ch));
        }
    }
    
    (true, "验证通过".to_string())
}

/// 密码强度检查函数
/// 
/// 强度评级：
/// - 弱：只有一种字符类型，长度不足
/// - 中等：包含2种字符类型，长度适中
/// - 强：包含3种以上字符类型，长度充足
fn check_password_strength(password: &str) -> String {
    if password.is_empty() {
        return "无效：密码为空".to_string();
    }
    
    let len = password.chars().count();
    if len < 6 {
        return "弱：密码太短".to_string();
    }
    
    let mut has_lowercase = false;
    let mut has_uppercase = false;
    let mut has_digit = false;
    let mut has_special = false;
    
    for ch in password.chars() {
        if ch.is_ascii_lowercase() {
            has_lowercase = true;
        } else if ch.is_ascii_uppercase() {
            has_uppercase = true;
        } else if ch.is_ascii_digit() {
            has_digit = true;
        } else if ch.is_ascii_punctuation() {
            has_special = true;
        }
    }
    
    let type_count = [has_lowercase, has_uppercase, has_digit, has_special]
        .iter()
        .filter(|&&x| x)
        .count();
    
    match (type_count, len) {
        (1, _) => "弱：只有一种字符类型".to_string(),
        (2, 6..=7) => "中等：包含2种字符类型".to_string(),
        (2, _) => "中等：包含2种字符类型，长度充足".to_string(),
        (3, 8..) => "强：包含3种字符类型，长度充足".to_string(),
        (4, 8..) => "很强：包含所有字符类型，长度充足".to_string(),
        _ => "中等：需要更多字符类型或长度".to_string(),
    }
}

/// 文本清理函数
/// 
/// 清理操作：
/// - 移除控制字符（除了换行和制表符）
/// - 标准化空白字符
/// - 移除不可打印字符
fn clean_text(text: &str) -> String {
    text.chars()
        .filter_map(|ch| {
            if ch.is_control() && ch != '\n' && ch != '\t' {
                // 移除控制字符，但保留换行和制表符
                None
            } else if ch == '\r' {
                // 回车符转换为换行符
                Some('\n')
            } else if ch == '\t' {
                // 制表符转换为空格
                Some(' ')
            } else if ch.is_ascii_graphic() || ch.is_whitespace() {
                // 保留可打印字符和空白字符
                Some(ch)
            } else if !ch.is_ascii() {
                // 保留非ASCII字符（Unicode字符）
                Some(ch)
            } else {
                // 移除其他不可打印字符
                None
            }
        })
        .collect::<String>()
        .split_whitespace()
        .collect::<Vec<&str>>()
        .join(" ")
}

/// 简单的词法分析函数
/// 
/// 识别的词法单元类型：
/// - 关键字
/// - 标识符
/// - 数字字面量
/// - 运算符
/// - 注释
#[derive(Debug, PartialEq)]
enum Token {
    Keyword(String),
    Identifier(String),
    Number(String),
    Operator(String),
    Comment(String),
    Unknown(String),
}

fn tokenize_simple(code: &str) -> Vec<Token> {
    let mut tokens = Vec::new();
    let mut chars = code.chars().peekable();
    
    while let Some(&ch) = chars.peek() {
        match ch {
            // 跳过空白字符
            c if c.is_whitespace() => {
                chars.next();
            }
            // 注释
            '/' => {
                chars.next();
                if chars.peek() == Some(&'/') {
                    chars.next();
                    let mut comment = String::new();
                    while let Some(c) = chars.next() {
                        if c == '\n' {
                            break;
                        }
                        comment.push(c);
                    }
                    tokens.push(Token::Comment(comment.trim().to_string()));
                } else {
                    tokens.push(Token::Operator("/".to_string()));
                }
            }
            // 数字
            c if c.is_ascii_digit() => {
                let mut number = String::new();
                while let Some(&c) = chars.peek() {
                    if c.is_ascii_digit() {
                        number.push(chars.next().unwrap());
                    } else {
                        break;
                    }
                }
                tokens.push(Token::Number(number));
            }
            // 标识符和关键字
            c if c.is_alphabetic() || c == '_' => {
                let mut identifier = String::new();
                while let Some(&c) = chars.peek() {
                    if c.is_alphanumeric() || c == '_' {
                        identifier.push(chars.next().unwrap());
                    } else {
                        break;
                    }
                }
                
                // 检查是否为关键字
                let token = match identifier.as_str() {
                    "let" | "fn" | "if" | "else" | "while" | "for" => Token::Keyword(identifier),
                    _ => Token::Identifier(identifier),
                };
                tokens.push(token);
            }
            // 运算符
            '=' | '+' | '-' | '*' | '<' | '>' | '!' => {
                tokens.push(Token::Operator(chars.next().unwrap().to_string()));
            }
            // 分隔符
            '(' | ')' | '{' | '}' | '[' | ']' | ',' | ';' => {
                tokens.push(Token::Operator(chars.next().unwrap().to_string()));
            }
            // 未知字符
            _ => {
                tokens.push(Token::Unknown(chars.next().unwrap().to_string()));
            }
        }
    }
    
    tokens
}

/// 简单的字形（grapheme）计数函数
/// 
/// 注：这是一个简化版本，真正的字形聚类需要更复杂的 Unicode 规则
/// 实际项目中应该使用专门的库如 `unicode-segmentation`
fn count_graphemes(text: &str) -> usize {
    let mut count = 0;
    let mut chars = text.chars();
    
    while let Some(ch) = chars.next() {
        count += 1;
        
        // 简化处理：跳过组合字符（在实际实现中需要更复杂的逻辑）
        if ch.is_ascii() {
            continue;
        }
        
        // 对于非ASCII字符，这个简化版本只计算基础字符
        // 在真实实现中，需要处理组合字符、修饰符等
    }
    
    count
}
